{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "dcf83b17-7109-48c3-8920-2662d498210e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "start_time = time.time()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "5128068c-2570-42b2-b9b5-8345e8c9641e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import glob\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn import svm\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.datasets import make_classification\n",
    "from sklearn.model_selection import GridSearchCV, train_test_split\n",
    "from sklearn.metrics import classification_report, accuracy_score\n",
    "from mpl_toolkits.mplot3d import Axes3D"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf65785-13f0-44ed-ac0d-d4d3391f5b20",
   "metadata": {},
   "source": [
    "### 设置训练集和测试集数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "283d869f-9975-4056-89e6-716b810f6ed5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 1 2 3\n",
    "target = 2\n",
    "\n",
    "if target==1:\n",
    "    data_name = '0618'\n",
    "elif target==2:\n",
    "    data_name = '0854'\n",
    "elif target==3:\n",
    "    data_name = '1066'\n",
    "\n",
    "# 设置训练集数据\n",
    "# 获取指定的CSV文件\n",
    "csv_files = glob.glob(f'./RGB_data/data_{data_name}_new.csv')\n",
    "\n",
    "# 设置测试集数据\n",
    "new_image_path = f'./input_data/{data_name}.png'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3d2b754-0265-4117-a546-538da2f31e9b",
   "metadata": {},
   "source": [
    "# TRAIN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "ac41cd2a-913c-4322-aa1b-f187c36f371e",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(39, 4)\n"
     ]
    }
   ],
   "source": [
    "# 初始化一个空的DataFrame来存储合并后的数据\n",
    "data = pd.DataFrame()\n",
    "\n",
    "# 遍历所有CSV文件并将它们合并\n",
    "for file in csv_files:\n",
    "    df = pd.read_csv(file)\n",
    "    data = pd.concat([data, df], ignore_index=True)\n",
    "\n",
    "# 现在all_data包含了所有CSV文件的数据\n",
    "print(data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3c842420-8c91-4fa3-bfa2-1f43a100dabd",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((39, 3), (39,), pandas.core.frame.DataFrame, pandas.core.series.Series)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 读入特征和标签\n",
    "features = data.drop('Label', axis=1) # 按列操作取名为’Label以外的列\n",
    "labels = data['Label']\n",
    "features.shape,labels.shape,type(features),type(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "2bad1adc-8161-43ca-a09d-8f7b5cb4d764",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 归一化\n",
    "scaler = StandardScaler()\n",
    "\n",
    "features = scaler.fit_transform(features)\n",
    "features = pd.DataFrame(features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "48be8177-c8cf-4f42-bbe5-72cd3071ab0f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 划分数据集\n",
    "X_train, X_test, y_train, y_test = train_test_split(features, labels,\n",
    "                                     test_size=0.25, random_state=42)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "de21f354-6867-4729-bc50-a7a23e4ffec0",
   "metadata": {
    "jp-MarkdownHeadingCollapsed": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Fitting 10 folds for each of 42 candidates, totalling 420 fits\n",
      "Best parameters: {'C': 100, 'gamma': 0.001, 'kernel': 'rbf'}\n",
      "Best cross-validation score: 0.9666666666666666\n"
     ]
    }
   ],
   "source": [
    "#网格搜索\n",
    "svc_grid = svm.SVC()\n",
    "param_grid = {\n",
    "    'C' : [100, 10, 1, 0.1, 0.01, 0.001, 0.0001],\n",
    "    'gamma' : [0.001, 0.01, 0.1, 1, 10, 100],\n",
    "    'kernel' : ['rbf']\n",
    "}\n",
    "#estimator是上面创建的SVC实例->svc\n",
    "grid_search = GridSearchCV(estimator=svc_grid, param_grid=param_grid,\n",
    "                           cv=10, scoring='accuracy', verbose=1)\n",
    "#模型训练\n",
    "grid_search.fit(X_train, y_train)\n",
    "\n",
    "# 输出最佳参数和最佳分数\n",
    "print(\"Best parameters:\", grid_search.best_params_)\n",
    "print(\"Best cross-validation score:\", grid_search.best_score_)\n",
    "\n",
    "#使用最佳参数和训练集数据训练最终模型\n",
    "clf = grid_search.best_estimator_\n",
    "y_pred = clf.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5a8c410a-705f-40af-8443-9d165be3c383",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "共39个数据, 18个正样本，21个负样本\n",
      "\n",
      "Model accuracy: 1.00\n",
      "\n",
      "Classification Report:\n",
      "               precision    recall  f1-score   support\n",
      "\n",
      "           0       1.00      1.00      1.00         6\n",
      "           1       1.00      1.00      1.00         4\n",
      "\n",
      "    accuracy                           1.00        10\n",
      "   macro avg       1.00      1.00      1.00        10\n",
      "weighted avg       1.00      1.00      1.00        10\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#输出训练结果\n",
    "# 数据量\n",
    "positive_count = data[data['Label'] == 1]['Label'].count()\n",
    "negative_count = data[data['Label'] == 0]['Label'].count()\n",
    "\n",
    "print(f'共{data.shape[0]}个数据, {positive_count}个正样本，{negative_count}个负样本\\n')\n",
    "\n",
    "# 计算并打印准确率\n",
    "accuracy = accuracy_score(y_test, y_pred)\n",
    "print(f'Model accuracy: {accuracy:.2f}\\n')\n",
    "\n",
    "# 计算并打印分类报告\n",
    "report = classification_report(y_test, y_pred)\n",
    "print('Classification Report:\\n', report)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9d03120b-0afc-4590-acd2-3ee25fefbac3",
   "metadata": {
    "jupyter": {
     "source_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def plot_svm_decision_boundaries(clf, X_train, y_train):\n",
    "    # 创建一个图形窗口，大小为20x10英寸\n",
    "    fig = plt.figure(figsize=(20, 12))\n",
    "\n",
    "    # 创建四个子图，排列为2行2列\n",
    "    # axs是一个2x2的数组，每个元素代表一个子图对象\n",
    "    axs = fig.subplots(2, 2)\n",
    "\n",
    "    # 将子图数组展平，方便索引\n",
    "    axs = axs.flatten()\n",
    "\n",
    "    # BGR (3D) 图\n",
    "    # 创建3D子图，位置在左上角（221表示2行2列中的第1个）\n",
    "    ax1 = fig.add_subplot(221, projection='3d')\n",
    "    # 绘制BGR数据点\n",
    "    ax1.scatter(X_train[0], X_train[1], X_train[2], c=y_train, cmap=plt.cm.Paired)\n",
    "    # 设置坐标轴标签\n",
    "    ax1.set_xlabel('B')\n",
    "    ax1.set_ylabel('G')\n",
    "    ax1.set_zlabel('R')\n",
    "    # 设置子图标题\n",
    "    ax1.set_title('BGR Channels')\n",
    "\n",
    "    # 获取支持向量\n",
    "    support_vectors = clf.support_vectors_\n",
    "    # 在3D图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 0], support_vectors[:, 1], support_vectors[:, 2], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 计算并绘制决策边界\n",
    "    w = clf.coef_[0]\n",
    "    b = clf.intercept_[0]\n",
    "    xx = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 10)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 10)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[0] / w[2] * X1 - w[1] / w[2] * X2 - b / w[2]\n",
    "    ax1.plot_surface(X1, X2, Z, alpha=0.5, rstride=1, cstride=1, color='k', linewidth=0)\n",
    "\n",
    "    # RG 图 21\n",
    "    ax2 = axs[1]\n",
    "    ax2.scatter(X_train[2], X_train[1], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax2.set_xlabel('R')\n",
    "    ax2.set_ylabel('G')\n",
    "    ax2.set_title('RG Channels')\n",
    "\n",
    "    # 在RG图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 2], support_vectors[:, 1], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 绘制RG的决策边界\n",
    "    xx = np.linspace(X_train[2].min() - 1, X_train[2].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[2] / w[1] * X1 - b / w[1]\n",
    "    ax2.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # RB 图 20\n",
    "    ax3 = axs[2]\n",
    "    ax3.scatter(X_train[2], X_train[0], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax3.set_xlabel('R')\n",
    "    ax3.set_ylabel('B')\n",
    "    ax3.set_title('RB Channels')\n",
    "\n",
    "    # 在RB图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 2], support_vectors[:, 0], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')\n",
    "\n",
    "    # 绘制RB的决策边界\n",
    "    xx = np.linspace(X_train[2].min() - 1, X_train[2].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[2] / w[0] * X1 - b / w[0]\n",
    "    ax3.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # BG 图 01\n",
    "    ax4 = axs[3]\n",
    "    ax4.scatter(X_train[0], X_train[1], c=y_train, cmap=plt.cm.Paired)\n",
    "    ax4.set_xlabel('B')\n",
    "    ax4.set_ylabel('G')\n",
    "    ax4.set_title('BG Channels')\n",
    "\n",
    "    # 在BG图中绘制支持向量\n",
    "    ax1.scatter(support_vectors[:, 0], support_vectors[:, 1], s=100,\n",
    "                 linewidth=1, facecolors='none', edgecolors='k')    \n",
    "\n",
    "    # 绘制BG的决策边界\n",
    "    xx = np.linspace(X_train[0].min() - 1, X_train[0].max() + 1, 500)\n",
    "    yy = np.linspace(X_train[1].min() - 1, X_train[1].max() + 1, 500)\n",
    "    X1, X2 = np.meshgrid(xx, yy)\n",
    "    Z = -w[0] / w[1] * X1 - b / w[1]\n",
    "    ax4.contour(X1, X2, Z, colors='k', levels=[0], linestyles=['-'])\n",
    "\n",
    "    # 自动调整子图布局，避免重叠\n",
    "    plt.tight_layout()\n",
    "    # 显示图形\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3c4d28a6-3838-47c5-8a5b-a916c447b355",
   "metadata": {},
   "source": [
    "##### 绘制数据点图像、支持向量和决策平面"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a474e3e-8800-41c9-9934-91853636bfc6",
   "metadata": {},
   "source": [
    "#绘制linear核训练下的图像\n",
    "plot_svm_decision_boundaries(clf, X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "31ca4087-55e9-4956-bfd4-14e5617ee1a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "from joblib import dump, load\n",
    "\n",
    "# 保存模型\n",
    "dump(clf, './model/svm_model_kernel.joblib')\n",
    "\n",
    "# 加载模型\n",
    "clf_loaded = load('./model/svm_model_kernel.joblib')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5815d8fd-2c09-4c61-8063-07ba9f8ec997",
   "metadata": {},
   "source": [
    "# TEST"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "2e893c72-470d-467e-a51d-19b9d31151ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "import cv2\n",
    "import os\n",
    "from joblib import load"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "0a1bf4d3-9411-495c-8c14-b84805b95fca",
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model(model_path):\n",
    "    return load(model_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9658fa3c-fff7-4d4f-864f-ca7b95ff9c73",
   "metadata": {},
   "outputs": [],
   "source": [
    "def preprocess_image(image):\n",
    "    h, w, _ = image.shape\n",
    "    \n",
    "    blue_channel = image[:, :, 0].reshape(-1)\n",
    "    green_channel = image[:, :, 1].reshape(-1)\n",
    "    red_channel = image[:, :, 2].reshape(-1)\n",
    "\n",
    "    img_array = np.stack((blue_channel, green_channel, red_channel), axis=1)\n",
    "\n",
    "    print(img_array.shape)\n",
    "    \n",
    "    return img_array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "b4da2fb2-4cd8-41b4-92dd-8edd8a99df92",
   "metadata": {},
   "outputs": [],
   "source": [
    "model_path = './model/svm_model_kernel.joblib'\n",
    "clf = load_model(model_path)\n",
    "\n",
    "# 加载新的图片\n",
    "new_image = cv2.imread(new_image_path)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7ad350af-aeea-4f98-9c7a-ec25d50bfb83",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(125000, 3)\n"
     ]
    }
   ],
   "source": [
    "new_features = preprocess_image(new_image)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "51d0b2da-7d30-49ec-9278-b1542ad027d2",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/crisi/miniconda3/envs/PR/lib/python3.9/site-packages/sklearn/base.py:493: UserWarning: X does not have valid feature names, but StandardScaler was fitted with feature names\n",
      "  warnings.warn(\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "((125000, 3), numpy.ndarray)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 使用相同的StandardScaler进行标准化\n",
    "new_features = scaler.transform(new_features)\n",
    "new_features.shape, type(new_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "43cde813-fa18-4def-8874-85d46abe880f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用模型进行预测\n",
    "prediction = clf.predict(new_features)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "c21bf4da-84fd-4e35-8df7-3bed81d7c0a4",
   "metadata": {},
   "outputs": [],
   "source": [
    "predictions = clf.predict(new_features)\n",
    "\n",
    "# 将预测结果应用到图片上\n",
    "# original_image 是原始图片的NumPy数组\n",
    "original_image = new_image\n",
    "height, width, _ = original_image.shape\n",
    "predicted_image = np.zeros_like(original_image)\n",
    "\n",
    "for i in range(height):\n",
    "    for j in range(width):\n",
    "        # 获取当前像素的索引\n",
    "        pixel_index = i * width + j\n",
    "        \n",
    "        # 根据预测结果设置像素的颜色\n",
    "        if predictions[pixel_index] == 1:\n",
    "            predicted_image[i, j] = (255, 255, 255)  # 白色\n",
    "        else:\n",
    "            predicted_image[i, j] = (0, 0, 0)  # 黑色"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "12de4fb7-4df6-4c8b-b408-2273e821ba5c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Predicted image saved to ./result_new/pred_0618_kernel_.jpg\n"
     ]
    }
   ],
   "source": [
    "# 显示原始图片\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.imshow(cv2.cvtColor(original_image, cv2.COLOR_BGR2RGB))\n",
    "plt.title('Original Image')\n",
    "plt.axis('off')\n",
    "\n",
    "# 显示预测后的图片\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.imshow(cv2.cvtColor(predicted_image, cv2.COLOR_BGR2RGB))\n",
    "plt.title('Predicted Image')\n",
    "plt.axis('off')\n",
    "\n",
    "# 显示图像\n",
    "plt.show()\n",
    "    \n",
    "# 保存预测后的图片\n",
    "new_image_name = os.path.splitext(os.path.basename(new_image_path))[0]\n",
    "save_path = f'./result_new/pred_{new_image_name}_kernel_.jpg'\n",
    "cv2.imwrite(save_path, predicted_image)\n",
    "print(f'Predicted image saved to {save_path}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "e90dc151-1d7a-4859-bcf0-cf0c92080018",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Elapsed time: 2.815129518508911 seconds\n"
     ]
    }
   ],
   "source": [
    "end_time = time.time()\n",
    "# 计算并打印运行时间\n",
    "elapsed_time = end_time - start_time\n",
    "print(f\"Elapsed time: {elapsed_time} seconds\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "8579604a-a5ae-42ca-98b0-abe97374ea7f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pixel Accuracy (PA): 0.9322\n",
      "Intersection over Union (IoU): 0.8845\n"
     ]
    }
   ],
   "source": [
    "import cv2\n",
    "import numpy as np\n",
    "from sklearn.metrics import confusion_matrix\n",
    "\n",
    "def calculate_performance_metrics(y_true, y_pred):\n",
    "    # 计算混淆矩阵\n",
    "    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()\n",
    "    \n",
    "    # 计算像素准确率（PA）\n",
    "    pa = (tp + tn) / (tp + tn + fp + fn)\n",
    "    \n",
    "    # 计算交并比（IoU）\n",
    "    iou = tp / (tp + fp + fn)\n",
    "    \n",
    "    return pa, iou\n",
    "\n",
    "def load_and_mask_binary_image(image_path):\n",
    "    # 加载图像\n",
    "    image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)\n",
    "    if image is None:\n",
    "        raise ValueError(f\"无法加载图像：{image_path}\")\n",
    "    \n",
    "    # 创建掩码以仅保留二值像素（0或255）\n",
    "    mask = (image == 0) | (image == 255)\n",
    "    # 应用掩码并转换为二值图像\n",
    "    binary_image = image.copy()\n",
    "    binary_image[~mask] = 0  # 将非二值像素设置为0\n",
    "    return binary_image, mask\n",
    "\n",
    "# 输入图像的路径\n",
    "test_image_path = save_path  # 测试得到的图像路径\n",
    "annotated_image_path = f'./input_data/{data_name}_label.png'  # 标注的图像路径\n",
    "\n",
    "# 加载并处理图像\n",
    "y_true, true_mask = load_and_mask_binary_image(annotated_image_path)\n",
    "y_pred, _ = load_and_mask_binary_image(test_image_path)\n",
    "\n",
    "# 将图像转换为二值数组（0或1）\n",
    "y_true_binary = (y_true > 0).astype(int)\n",
    "y_pred_binary = (y_pred > 0).astype(int)\n",
    "\n",
    "# 应用掩码以仅考虑二值像素\n",
    "y_true_binary = y_true_binary[true_mask]\n",
    "y_pred_binary = y_pred_binary[true_mask]\n",
    "\n",
    "# 计算性能指标\n",
    "pa, iou = calculate_performance_metrics(y_true_binary, y_pred_binary)\n",
    "\n",
    "print(f\"Pixel Accuracy (PA): {pa:.4f}\")\n",
    "print(f\"Intersection over Union (IoU): {iou:.4f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "051b9da4-412e-41a2-aff8-710b3697220f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.18"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
